home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / hplip / unload.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  23.0 KB  |  696 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __version__ = '3.3'
  5. __mod__ = 'hp-unload'
  6. __title__ = 'Photo Card Access Utility'
  7. __doc__ = 'Access inserted photo cards on supported HPLIP printers. This provides an alternative for older devices that do not support USB mass storage or for access to photo cards over a network.'
  8. import sys
  9. import os
  10. import os.path as os
  11. import getopt
  12. import re
  13. import cmd
  14. import time
  15. import fnmatch
  16. import string
  17. import operator
  18.  
  19. try:
  20.     import readline
  21. except ImportError:
  22.     pass
  23.  
  24. from base.g import *
  25. from base import device, utils, tui, module
  26. from prnt import cups
  27. from pcard import photocard
  28.  
  29. class Console(cmd.Cmd):
  30.     
  31.     def __init__(self, pc):
  32.         cmd.Cmd.__init__(self)
  33.         self.intro = "Type 'help' for a list of commands. Type 'exit' to quit."
  34.         self.pc = pc
  35.         disk_info = self.pc.info()
  36.         pc.write_protect = disk_info[8]
  37.         if pc.write_protect:
  38.             log.warning('Photo card is write protected.')
  39.         
  40.         self.prompt = log.bold('pcard: %s > ' % self.pc.pwd())
  41.  
  42.     
  43.     def do_hist(self, args):
  44.         '''Print a list of commands that have been entered'''
  45.         print self._hist
  46.  
  47.     
  48.     def do_exit(self, args):
  49.         '''Exits from the console'''
  50.         return -1
  51.  
  52.     
  53.     def do_quit(self, args):
  54.         '''Exits from the console'''
  55.         return -1
  56.  
  57.     
  58.     def do_EOF(self, args):
  59.         '''Exit on system end of file character'''
  60.         return self.do_exit(args)
  61.  
  62.     
  63.     def do_help(self, args):
  64.         """Get help on commands
  65.            'help' or '?' with no arguments prints a list of commands for which help is available
  66.            'help <command>' or '? <command>' gives help on <command>
  67.         """
  68.         cmd.Cmd.do_help(self, args)
  69.  
  70.     
  71.     def preloop(self):
  72.         '''Initialization before prompting user for commands.
  73.            Despite the claims in the Cmd documentaion, Cmd.preloop() is not a stub.
  74.         '''
  75.         cmd.Cmd.preloop(self)
  76.         self._hist = []
  77.         self._locals = { }
  78.         self._globals = { }
  79.  
  80.     
  81.     def postloop(self):
  82.         '''Take care of any unfinished business.
  83.            Despite the claims in the Cmd documentaion, Cmd.postloop() is not a stub.
  84.         '''
  85.         cmd.Cmd.postloop(self)
  86.         print 'Exiting...'
  87.  
  88.     
  89.     def precmd(self, line):
  90.         ''' This method is called after the line has been input but before
  91.             it has been interpreted. If you want to modifdy the input line
  92.             before execution (for example, variable substitution) do it here.
  93.         '''
  94.         self._hist += [
  95.             line.strip()]
  96.         return line
  97.  
  98.     
  99.     def postcmd(self, stop, line):
  100.         '''If you want to stop the console, return something that evaluates to true.
  101.            If you want to do some post command processing, do it here.
  102.         '''
  103.         return stop
  104.  
  105.     
  106.     def emptyline(self):
  107.         '''Do nothing on empty input line'''
  108.         pass
  109.  
  110.     
  111.     def default(self, line):
  112.         print log.bold("ERROR: Unrecognized command. Use 'help' to list commands.")
  113.  
  114.     
  115.     def do_ldir(self, args):
  116.         ''' List local directory contents.'''
  117.         os.system('ls -l')
  118.  
  119.     
  120.     def do_lls(self, args):
  121.         ''' List local directory contents.'''
  122.         os.system('ls -l')
  123.  
  124.     
  125.     def do_dir(self, args):
  126.         '''Synonym for the ls command.'''
  127.         return self.do_ls(args)
  128.  
  129.     
  130.     def do_ls(self, args):
  131.         '''List photo card directory contents.'''
  132.         args = args.strip().lower()
  133.         files = self.pc.ls(True, args)
  134.         total_size = 0
  135.         formatter = utils.TextFormatter(({
  136.             'width': 14,
  137.             'margin': 2 }, {
  138.             'width': 12,
  139.             'margin': 2,
  140.             'alignment': utils.TextFormatter.RIGHT }, {
  141.             'width': 30,
  142.             'margin': 2 }))
  143.         print 
  144.         print log.bold(formatter.compose(('Name', 'Size', 'Type')))
  145.         num_files = 0
  146.         for d in self.pc.current_directories():
  147.             if d[0] in ('.', '..'):
  148.                 print formatter.compose((d[0], '', 'directory'))
  149.                 continue
  150.             print formatter.compose((d[0] + '/', '', 'directory'))
  151.         
  152.         for f in self.pc.current_files():
  153.             print formatter.compose((f[0], utils.format_bytes(f[2]), self.pc.classify_file(f[0])))
  154.             num_files += 1
  155.             total_size += f[2]
  156.         
  157.         print log.bold('% d files, %s' % (num_files, utils.format_bytes(total_size, True)))
  158.  
  159.     
  160.     def do_df(self, args):
  161.         '''Display free space on photo card.
  162.         Options:
  163.         -h\tDisplay in human readable format
  164.         '''
  165.         freespace = self.pc.df()
  166.         if args.strip().lower() == '-h':
  167.             fs = utils.format_bytes(freespace)
  168.         else:
  169.             fs = utils.commafy(freespace)
  170.         print 'Freespace = %s Bytes' % fs
  171.  
  172.     
  173.     def do_cp(self, args, remove_after_copy = False):
  174.         '''Copy files from photo card to current local directory.
  175.         Usage:
  176.         \tcp FILENAME(S)|GLOB PATTERN(S)
  177.         Example:
  178.         \tCopy all JPEG and GIF files and a file named thumbs.db from photo card to local directory:
  179.         \tcp *.jpg *.gif thumbs.db
  180.         '''
  181.         args = args.strip().lower()
  182.         matched_files = self.pc.match_files(args)
  183.         if len(matched_files) == 0:
  184.             print 'ERROR: File(s) not found.'
  185.         else:
  186.             (total, delta) = self.pc.cp_multiple(matched_files, remove_after_copy, self.cp_status_callback, self.rm_status_callback)
  187.             print log.bold('\n%s transfered in %d sec (%d KB/sec)' % (utils.format_bytes(total), delta, total / 1024 / delta))
  188.  
  189.     
  190.     def do_unload(self, args):
  191.         """Unload all image files from photocard to current local directory.
  192.         Note:
  193.         \tSubdirectories on photo card are not preserved
  194.         Options:
  195.         -x\tDon't remove files after copy
  196.         -p\tPrint unload list but do not copy or remove files"""
  197.         args = args.lower().strip().split()
  198.         dont_remove = False
  199.         if '-x' in args:
  200.             if self.pc.write_protect:
  201.                 log.error('Photo card is write protected. -x not allowed.')
  202.                 return None
  203.             dont_remove = True
  204.         
  205.         unload_list = self.pc.get_unload_list()
  206.         print 
  207.         if len(unload_list) > 0:
  208.             if '-p' in args:
  209.                 max_len = 0
  210.                 for u in unload_list:
  211.                     max_len = max(max_len, len(u[0]))
  212.                 
  213.                 formatter = utils.TextFormatter(({
  214.                     'width': max_len + 2,
  215.                     'margin': 2 }, {
  216.                     'width': 12,
  217.                     'margin': 2,
  218.                     'alignment': utils.TextFormatter.RIGHT }, {
  219.                     'width': 12,
  220.                     'margin': 2 }))
  221.                 print 
  222.                 print log.bold(formatter.compose(('Name', 'Size', 'Type')))
  223.                 total = 0
  224.                 for u in unload_list:
  225.                     print formatter.compose(('%s' % u[0], utils.format_bytes(u[1]), '%s/%s' % (u[2], u[3])))
  226.                     total += u[1]
  227.                 
  228.                 print log.bold('Found %d files to unload, %s' % (len(unload_list), utils.format_bytes(total, True)))
  229.             else:
  230.                 print log.bold('Unloading %d files...' % len(unload_list))
  231.                 (total, delta, was_cancelled) = self.pc.unload(unload_list, self.cp_status_callback, self.rm_status_callback, dont_remove)
  232.                 print log.bold('\n%s unloaded in %d sec (%d KB/sec)' % (utils.format_bytes(total), delta, total / 1024 / delta))
  233.         else:
  234.             print 'No image, audio, or video files found.'
  235.  
  236.     
  237.     def cp_status_callback(self, src, trg, size):
  238.         if size == 1:
  239.             print 
  240.             print log.bold('Copying %s...' % src)
  241.         else:
  242.             print '\nCopied %s to %s (%s)...' % (src, trg, utils.format_bytes(size))
  243.  
  244.     
  245.     def rm_status_callback(self, src):
  246.         print 'Removing %s...' % src
  247.  
  248.     
  249.     def do_rm(self, args):
  250.         '''Remove files from photo card.'''
  251.         if self.pc.write_protect:
  252.             log.error('Photo card is write protected. rm not allowed.')
  253.             return None
  254.         args = args.strip().lower()
  255.         matched_files = self.pc.match_files(args)
  256.         self.pc.ls()
  257.  
  258.     
  259.     def do_mv(self, args):
  260.         '''Move files off photocard'''
  261.         if self.pc.write_protect:
  262.             log.error('Photo card is write protected. mv not allowed.')
  263.             return None
  264.         self.do_cp(args, True)
  265.  
  266.     
  267.     def do_lpwd(self, args):
  268.         '''Print name of local current/working directory.'''
  269.         print os.getcwd()
  270.  
  271.     
  272.     def do_lcd(self, args):
  273.         '''Change current local working directory.'''
  274.         
  275.         try:
  276.             os.chdir(args.strip())
  277.         except OSError:
  278.             print log.bold('ERROR: Directory not found.')
  279.  
  280.         print os.getcwd()
  281.  
  282.     
  283.     def do_pwd(self, args):
  284.         '''Print name of photo card current/working directory
  285.         Usage:
  286.         \t>pwd'''
  287.         print self.pc.pwd()
  288.  
  289.     
  290.     def do_cd(self, args):
  291.         '''Change current working directory on photo card.
  292.         Note:
  293.         \tYou may only specify one directory level at a time.
  294.         Usage:
  295.         \tcd <directory>
  296.         '''
  297.         args = args.lower().strip()
  298.         if args == '..':
  299.             if self.pc.pwd() != '/':
  300.                 self.pc.cdup()
  301.             
  302.         elif args == '.':
  303.             pass
  304.         elif args == '/':
  305.             self.pc.cd('/')
  306.         else:
  307.             matched_dirs = self.pc.match_dirs(args)
  308.             if len(matched_dirs) == 0:
  309.                 print 'Directory not found'
  310.             elif len(matched_dirs) > 1:
  311.                 print 'Pattern matches more than one directory'
  312.             else:
  313.                 self.pc.cd(matched_dirs[0])
  314.         self.prompt = log.bold('pcard: %s > ' % self.pc.pwd())
  315.  
  316.     
  317.     def do_cdup(self, args):
  318.         '''Change to parent directory.'''
  319.         self.do_cd('..')
  320.  
  321.     
  322.     def do_cache(self, args):
  323.         '''Display current cache entries, or turn cache on/off.
  324.         Usage:
  325.         \tDisplay: cache
  326.         \tTurn on: cache on
  327.         \tTurn off: cache off
  328.         '''
  329.         args = args.strip().lower()
  330.         if args == 'on':
  331.             self.pc.cache_control(True)
  332.         elif args == 'off':
  333.             self.pc.cache_control(False)
  334.         elif self.pc.cache_state():
  335.             cache_info = self.pc.cache_info()
  336.             t = cache_info.keys()
  337.             t.sort()
  338.             print 
  339.             for s in t:
  340.                 print 'sector %d (%d hits)' % (s, cache_info[s])
  341.             
  342.             print log.bold('Total cache usage: %s (%s maximum)' % (utils.format_bytes(len(t) * 512), utils.format_bytes(photocard.MAX_CACHE * 512)))
  343.             print log.bold('Total cache sectors: %s of %s' % (utils.commafy(len(t)), utils.commafy(photocard.MAX_CACHE)))
  344.         else:
  345.             print 'Cache is off.'
  346.  
  347.     
  348.     def do_sector(self, args):
  349.         '''Display sector data.
  350.         Usage:
  351.         \tsector <sector num>
  352.         '''
  353.         args = args.strip().lower()
  354.         cached = False
  355.         
  356.         try:
  357.             sector = int(args)
  358.         except ValueError:
  359.             print 'Sector must be specified as a number'
  360.             return None
  361.  
  362.         if self.pc.cache_check(sector) > 0:
  363.             print 'Cached sector'
  364.         
  365.         print repr(self.pc.sector(sector))
  366.  
  367.     
  368.     def do_tree(self, args):
  369.         '''Display photo card directory tree.'''
  370.         tree = self.pc.tree()
  371.         print 
  372.         self.print_tree(tree)
  373.  
  374.     
  375.     def print_tree(self, tree, level = 0):
  376.         for d in tree:
  377.             if type(tree[d]) == type({ }):
  378.                 print ''.join([
  379.                     ' ' * level * 4,
  380.                     d,
  381.                     '/'])
  382.                 self.print_tree(tree[d], level + 1)
  383.                 continue
  384.         
  385.  
  386.     
  387.     def do_reset(self, args):
  388.         '''Reset the cache.'''
  389.         self.pc.cache_reset()
  390.  
  391.     
  392.     def do_card(self, args):
  393.         '''Print info about photocard.'''
  394.         print 
  395.         print 'Device URI = %s' % self.pc.device.device_uri
  396.         print 'Model = %s' % self.pc.device.model_ui
  397.         print 'Working dir = %s' % self.pc.pwd()
  398.         disk_info = self.pc.info()
  399.         print 'OEM ID = %s' % disk_info[0]
  400.         print 'Bytes/sector = %d' % disk_info[1]
  401.         print 'Sectors/cluster = %d' % disk_info[2]
  402.         print 'Reserved sectors = %d' % disk_info[3]
  403.         print 'Root entries = %d' % disk_info[4]
  404.         print 'Sectors/FAT = %d' % disk_info[5]
  405.         print 'Volume label = %s' % disk_info[6]
  406.         print 'System ID = %s' % disk_info[7]
  407.         print 'Write protected = %d' % disk_info[8]
  408.         print 'Cached sectors = %s' % utils.commafy(len(self.pc.cache_info()))
  409.  
  410.     
  411.     def do_display(self, args):
  412.         '''Display an image with ImageMagick.
  413.         Usage:
  414.         \tdisplay <filename>'''
  415.         args = args.strip().lower()
  416.         matched_files = self.pc.match_files(args)
  417.         if len(matched_files) == 1:
  418.             typ = self.pc.classify_file(args).split('/')[0]
  419.             if typ == 'image':
  420.                 (fd, temp_name) = utils.make_temp_file()
  421.                 self.pc.cp(args, temp_name)
  422.                 os.system('display %s' % temp_name)
  423.                 os.remove(temp_name)
  424.             else:
  425.                 print 'File is not an image.'
  426.         elif len(matched_files) == 0:
  427.             print 'File not found.'
  428.         else:
  429.             print 'Only one file at a time may be specified for display.'
  430.  
  431.     
  432.     def do_show(self, args):
  433.         '''Synonym for the display command.'''
  434.         self.do_display(args)
  435.  
  436.     
  437.     def do_thumbnail(self, args):
  438.         '''Display an embedded thumbnail image with ImageMagick.
  439.         Note:
  440.         \tOnly works with JPEG/JFIF images with embedded JPEG/TIFF thumbnails
  441.         Usage:
  442.         \tthumbnail <filename>'''
  443.         args = args.strip().lower()
  444.         matched_files = self.pc.match_files(args)
  445.         if len(matched_files) == 1:
  446.             (typ, subtyp) = self.pc.classify_file(args).split('/')
  447.             if typ == 'image' and subtyp in ('jpeg', 'tiff'):
  448.                 exif_info = self.pc.get_exif(args)
  449.                 (dir_name, file_name) = os.path.split(args)
  450.                 (photo_name, photo_ext) = os.path.splitext(args)
  451.                 if 'JPEGThumbnail' in exif_info:
  452.                     (temp_file_fd, temp_file_name) = utils.make_temp_file()
  453.                     open(temp_file_name, 'wb').write(exif_info['JPEGThumbnail'])
  454.                     os.system('display %s' % temp_file_name)
  455.                     os.remove(temp_file_name)
  456.                 elif 'TIFFThumbnail' in exif_info:
  457.                     (temp_file_fd, temp_file_name) = utils.make_temp_file()
  458.                     open(temp_file_name, 'wb').write(exif_info['TIFFThumbnail'])
  459.                     os.system('display %s' % temp_file_name)
  460.                     os.remove(temp_file_name)
  461.                 else:
  462.                     print 'No thumbnail found.'
  463.             else:
  464.                 print 'Incorrect file type for thumbnail.'
  465.         elif len(matched_files) == 0:
  466.             print 'File not found.'
  467.         else:
  468.             print 'Only one file at a time may be specified for thumbnail display.'
  469.  
  470.     
  471.     def do_thumb(self, args):
  472.         '''Synonym for the thumbnail command.'''
  473.         self.do_thumbnail(args)
  474.  
  475.     
  476.     def do_exif(self, args):
  477.         '''Display EXIF info for file.
  478.         Usage:
  479.         \texif <filename>'''
  480.         args = args.strip().lower()
  481.         matched_files = self.pc.match_files(args)
  482.         if len(matched_files) == 1:
  483.             (typ, subtyp) = self.pc.classify_file(args).split('/')
  484.             if typ == 'image' and subtyp in ('jpeg', 'tiff'):
  485.                 exif_info = self.pc.get_exif(args)
  486.                 formatter = utils.TextFormatter(({
  487.                     'width': 40,
  488.                     'margin': 2 }, {
  489.                     'width': 40,
  490.                     'margin': 2 }))
  491.                 print 
  492.                 print log.bold(formatter.compose(('Tag', 'Value')))
  493.                 ee = exif_info.keys()
  494.                 ee.sort()
  495.                 for e in ee:
  496.                     if e not in ('JPEGThumbnail', 'TIFFThumbnail', 'Filename'):
  497.                         print formatter.compose((e, '%s' % exif_info[e]))
  498.                         continue
  499.                 
  500.             else:
  501.                 print 'Incorrect file type for thumbnail.'
  502.         elif len(matched_files) == 0:
  503.             print 'File not found.'
  504.         else:
  505.             print 'Only one file at a time may be specified for thumbnail display.'
  506.  
  507.     
  508.     def do_info(self, args):
  509.         '''Synonym for the exif command.'''
  510.         self.do_exif(args)
  511.  
  512.     
  513.     def do_about(self, args):
  514.         utils.log_title(__title__, __version__)
  515.  
  516.  
  517.  
  518. def status_callback(src, trg, size):
  519.     if size == 1:
  520.         print 
  521.         print log.bold('Copying %s...' % src)
  522.     else:
  523.         print '\nCopied %s to %s (%s)...' % (src, trg, utils.format_bytes(size))
  524.  
  525. mod = module.Module(__mod__, __title__, __version__, __doc__, None, (GUI_MODE, INTERACTIVE_MODE, NON_INTERACTIVE_MODE), (UI_TOOLKIT_QT3,))
  526. mod.setUsage(module.USAGE_FLAG_DEVICE_ARGS, extra_options = [
  527.     ('Output directory:', '-o<dir> or --output=<dir> (Defaults to current directory)(Only used for non-GUI modes)', 'option', False)], see_also_list = [
  528.     'hp-toolbox'])
  529. (opts, device_uri, printer_name, mode, ui_toolkit, loc) = mod.parseStdOpts('o', [
  530.     'output='])
  531. output_dir = os.getcwd()
  532. for o, a in opts:
  533.     if o in ('-o', '--output'):
  534.         output_dir = a
  535.     
  536.  
  537. if mode == GUI_MODE:
  538.     if not utils.canEnterGUIMode():
  539.         mode = INTERACTIVE_MODE
  540.     
  541.  
  542. if mode == GUI_MODE:
  543.     if ui_toolkit == 'qt4':
  544.         log.error('%s does not support Qt4. Please use Qt3 or run in -i or -n modes.')
  545.         sys.exit(1)
  546.     
  547.  
  548. if mode in (INTERACTIVE_MODE, NON_INTERACTIVE_MODE):
  549.     
  550.     try:
  551.         device_uri = mod.getDeviceUri(device_uri, printer_name, filter = {
  552.             'pcard-type': (operator.eq, 1) })
  553.         
  554.         try:
  555.             pc = photocard.PhotoCard(None, device_uri, printer_name)
  556.         except Error:
  557.             e = None
  558.             log.error('Unable to start photocard session: %s' % e.msg)
  559.             sys.exit(1)
  560.  
  561.         pc.set_callback(update_spinner)
  562.         
  563.         try:
  564.             pc.mount()
  565.         except Error:
  566.             log.error('Unable to mount photo card on device. Check that device is powered on and photo card is correctly inserted.')
  567.             pc.umount()
  568.             sys.exit(1)
  569.  
  570.         log.info(log.bold('\nPhotocard on device %s mounted' % pc.device.device_uri))
  571.         log.info(log.bold('DO NOT REMOVE PHOTO CARD UNTIL YOU EXIT THIS PROGRAM'))
  572.         output_dir = os.path.realpath(os.path.normpath(os.path.expanduser(output_dir)))
  573.         
  574.         try:
  575.             os.chdir(output_dir)
  576.         except OSError:
  577.             print log.bold('ERROR: Output directory %s not found.' % output_dir)
  578.             sys.exit(1)
  579.  
  580.         if mode == INTERACTIVE_MODE:
  581.             console = Console(pc)
  582.             
  583.             try:
  584.                 console.cmdloop()
  585.             except KeyboardInterrupt:
  586.                 log.error('Aborted.')
  587.             except Exception:
  588.                 e = None
  589.                 log.error('An error occured: %s' % e)
  590.             finally:
  591.                 pc.umount()
  592.  
  593.         else:
  594.             print 'Output directory is %s' % os.getcwd()
  595.             
  596.             try:
  597.                 unload_list = pc.get_unload_list()
  598.                 print 
  599.                 if len(unload_list) > 0:
  600.                     max_len = 0
  601.                     for u in unload_list:
  602.                         max_len = max(max_len, len(u[0]))
  603.                     
  604.                     formatter = utils.TextFormatter(({
  605.                         'width': max_len + 2,
  606.                         'margin': 2 }, {
  607.                         'width': 12,
  608.                         'margin': 2,
  609.                         'alignment': utils.TextFormatter.RIGHT }, {
  610.                         'width': 12,
  611.                         'margin': 2 }))
  612.                     print 
  613.                     print log.bold(formatter.compose(('Name', 'Size', 'Type')))
  614.                     total = 0
  615.                     for u in unload_list:
  616.                         print formatter.compose(('%s' % u[0], utils.format_bytes(u[1]), '%s/%s' % (u[2], u[3])))
  617.                         total += u[1]
  618.                     
  619.                     print log.bold('Found %d files to unload, %s\n' % (len(unload_list), utils.format_bytes(total, True)))
  620.                     print log.bold('Unloading files...\n')
  621.                     (total, delta, was_cancelled) = pc.unload(unload_list, status_callback, None, True)
  622.                     print log.bold('\n%s unloaded in %d sec (%d KB/sec)' % (utils.format_bytes(total), delta, total / 1024 / delta))
  623.             finally:
  624.                 pc.umount()
  625.  
  626.     except KeyboardInterrupt:
  627.         log.error('User exit')
  628.  
  629. else:
  630.     
  631.     try:
  632.         from qt import *
  633.         from ui import unloadform
  634.     except ImportError:
  635.         log.error('Unable to load Qt3 support. Is it installed?')
  636.         sys.exit(1)
  637.  
  638.     app = QApplication(sys.argv)
  639.     QObject.connect(app, SIGNAL('lastWindowClosed()'), app, SLOT('quit()'))
  640.     if loc is None:
  641.         loc = user_conf.get('ui', 'loc', 'system')
  642.         if loc.lower() == 'system':
  643.             loc = str(QTextCodec.locale())
  644.             log.debug('Using system locale: %s' % loc)
  645.         
  646.     
  647.     if loc.lower() != 'c':
  648.         e = 'utf8'
  649.         
  650.         try:
  651.             (l, x) = loc.split('.')
  652.             loc = '.'.join([
  653.                 l,
  654.                 e])
  655.         except ValueError:
  656.             l = loc
  657.             loc = '.'.join([
  658.                 loc,
  659.                 e])
  660.  
  661.         log.debug('Trying to load .qm file for %s locale.' % loc)
  662.         trans = QTranslator(None)
  663.         qm_file = 'hplip_%s.qm' % l
  664.         log.debug('Name of .qm file: %s' % qm_file)
  665.         loaded = trans.load(qm_file, prop.localization_dir)
  666.         if loaded:
  667.             app.installTranslator(trans)
  668.         else:
  669.             loc = 'c'
  670.     
  671.     if loc == 'c':
  672.         log.debug("Using default 'C' locale")
  673.     else:
  674.         log.debug('Using locale: %s' % loc)
  675.         QLocale.setDefault(QLocale(loc))
  676.         prop.locale = loc
  677.         
  678.         try:
  679.             locale.setlocale(locale.LC_ALL, locale.normalize(loc))
  680.         except locale.Error:
  681.             pass
  682.  
  683.     
  684.     try:
  685.         w = unloadform.UnloadForm([
  686.             'cups'], device_uri, printer_name)
  687.     except Error:
  688.         log.error('Unable to connect to HPLIP I/O. Please (re)start HPLIP and try again.')
  689.         sys.exit(1)
  690.  
  691.     app.setMainWidget(w)
  692.     w.show()
  693.     app.exec_loop()
  694. log.info('')
  695. log.info('Done.')
  696.